home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 1.0 beta / flock-1.0RC3.en-US.win32.exe / flock / components / nsUrlClassifierTable.js < prev    next >
Text File  |  2007-10-18  |  38KB  |  1,198 lines
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public License Version
  5.  * 1.1 (the "License"); you may not use this file except in compliance with
  6.  * the License. You may obtain a copy of the License at
  7.  * http://www.mozilla.org/MPL/
  8.  *
  9.  * Software distributed under the License is distributed on an "AS IS" basis,
  10.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11.  * for the specific language governing rights and limitations under the
  12.  * License.
  13.  *
  14.  * The Original Code is Url Classifier code
  15.  *
  16.  * The Initial Developer of the Original Code is
  17.  * Google Inc.
  18.  * Portions created by the Initial Developer are Copyright (C) 2006
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *   Tony Chang <tony@ponderer.org>
  23.  *
  24.  * Alternatively, the contents of this file may be used under the terms of
  25.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27.  * in which case the provisions of the GPL or the LGPL are applicable instead
  28.  * of those above. If you wish to allow use of your version of this file only
  29.  * under the terms of either the GPL or the LGPL, and not to allow others to
  30.  * use your version of this file under the terms of the MPL, indicate your
  31.  * decision by deleting the provisions above and replace them with the notice
  32.  * and other provisions required by the GPL or the LGPL. If you do not delete
  33.  * the provisions above, a recipient may use your version of this file under
  34.  * the terms of any one of the MPL, the GPL or the LGPL.
  35.  *
  36.  * ***** END LICENSE BLOCK ***** */
  37.  
  38. const Cc = Components.classes;
  39. const Ci = Components.interfaces;
  40.  
  41. // js/lang.js is needed for Function.prototype.inherts
  42. /* ***** BEGIN LICENSE BLOCK *****
  43.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  44.  *
  45.  * The contents of this file are subject to the Mozilla Public License Version
  46.  * 1.1 (the "License"); you may not use this file except in compliance with
  47.  * the License. You may obtain a copy of the License at
  48.  * http://www.mozilla.org/MPL/
  49.  *
  50.  * Software distributed under the License is distributed on an "AS IS" basis,
  51.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  52.  * for the specific language governing rights and limitations under the
  53.  * License.
  54.  *
  55.  * The Original Code is Google Safe Browsing.
  56.  *
  57.  * The Initial Developer of the Original Code is Google Inc.
  58.  * Portions created by the Initial Developer are Copyright (C) 2006
  59.  * the Initial Developer. All Rights Reserved.
  60.  *
  61.  * Contributor(s):
  62.  *   Aaron Boodman <aa@google.com> (original author)
  63.  *
  64.  * Alternatively, the contents of this file may be used under the terms of
  65.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  66.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  67.  * in which case the provisions of the GPL or the LGPL are applicable instead
  68.  * of those above. If you wish to allow use of your version of this file only
  69.  * under the terms of either the GPL or the LGPL, and not to allow others to
  70.  * use your version of this file under the terms of the MPL, indicate your
  71.  * decision by deleting the provisions above and replace them with the notice
  72.  * and other provisions required by the GPL or the LGPL. If you do not delete
  73.  * the provisions above, a recipient may use your version of this file under
  74.  * the terms of any one of the MPL, the GPL or the LGPL.
  75.  *
  76.  * ***** END LICENSE BLOCK ***** */
  77.  
  78. // This file has pure js helper functions. Hence you'll find metion
  79. // of browser-specific features in here.
  80.  
  81.  
  82. /**
  83.  * lang.js - The missing JavaScript language features
  84.  *
  85.  * WARNING: This class adds members to the prototypes of String, Array, and
  86.  * Function for convenience.
  87.  *
  88.  * The tradeoff is that the for/in statement will not work properly for those
  89.  * objects when this library is used.
  90.  *
  91.  * To work around this for Arrays, you may want to use the forEach() method,
  92.  * which is more fun and easier to read.
  93.  */
  94.  
  95. /**
  96.  * Returns true if the specified value is |null|
  97.  */
  98. function isNull(val) {
  99.   return val === null;
  100. }
  101.  
  102. /**
  103.  * Returns true if the specified value is an array
  104.  */
  105. function isArray(val) {
  106.   return isObject(val) && val.constructor == Array;
  107. }
  108.  
  109. /**
  110.  * Returns true if the specified value is a string
  111.  */
  112. function isString(val) {
  113.   return typeof val == "string";
  114. }
  115.  
  116. /**
  117.  * Returns true if the specified value is a boolean
  118.  */
  119. function isBoolean(val) {
  120.   return typeof val == "boolean";
  121. }
  122.  
  123. /**
  124.  * Returns true if the specified value is a number
  125.  */
  126. function isNumber(val) {
  127.   return typeof val == "number";
  128. }
  129.  
  130. /**
  131.  * Returns true if the specified value is a function
  132.  */
  133. function isFunction(val) {
  134.   return typeof val == "function";
  135. }
  136.  
  137. /**
  138.  * Returns true if the specified value is an object
  139.  */
  140. function isObject(val) {
  141.   return val && typeof val == "object";
  142. }
  143.  
  144. /**
  145.  * Returns an array of all the properties defined on an object
  146.  */
  147. function getObjectProps(obj) {
  148.   var ret = [];
  149.  
  150.   for (var p in obj) {
  151.     ret.push(p);
  152.   }
  153.  
  154.   return ret;
  155. }
  156.  
  157. /**
  158.  * Returns true if the specified value is an object which has no properties
  159.  * defined.
  160.  */
  161. function isEmptyObject(val) {
  162.   if (!isObject(val)) {
  163.     return false;
  164.   }
  165.  
  166.   for (var p in val) {
  167.     return false;
  168.   }
  169.  
  170.   return true;
  171. }
  172.  
  173. var getHashCode;
  174. var removeHashCode;
  175.  
  176. (function () {
  177.   var hashCodeProperty = "lang_hashCode_";
  178.  
  179.   /**
  180.    * Adds a lang_hashCode_ field to an object. The hash code is unique for the
  181.    * given object.
  182.    * @param obj {Object} The object to get the hash code for
  183.    * @returns {Number} The hash code for the object
  184.    */
  185.   getHashCode = function(obj) {
  186.     // In IE, DOM nodes do not extend Object so they do not have this method.
  187.     // we need to check hasOwnProperty because the proto might have this set.
  188.     if (obj.hasOwnProperty && obj.hasOwnProperty(hashCodeProperty)) {
  189.       return obj[hashCodeProperty];
  190.     }
  191.     if (!obj[hashCodeProperty]) {
  192.       obj[hashCodeProperty] = ++getHashCode.hashCodeCounter_;
  193.     }
  194.     return obj[hashCodeProperty];
  195.   };
  196.  
  197.   /**
  198.    * Removes the lang_hashCode_ field from an object.
  199.    * @param obj {Object} The object to remove the field from. 
  200.    */
  201.   removeHashCode = function(obj) {
  202.     obj.removeAttribute(hashCodeProperty);
  203.   };
  204.  
  205.   getHashCode.hashCodeCounter_ = 0;
  206. })();
  207.  
  208. /**
  209.  * Fast prefix-checker.
  210.  */
  211. String.prototype.startsWith = function(prefix) {
  212.   if (this.length < prefix.length) {
  213.     return false;
  214.   }
  215.  
  216.   if (this.substring(0, prefix.length) == prefix) {
  217.     return true;
  218.   }
  219.  
  220.   return false;
  221. }
  222.  
  223. /**
  224.  * Removes whitespace from the beginning and end of the string
  225.  */
  226. String.prototype.trim = function() {
  227.   return this.replace(/^\s+|\s+$/g, "");
  228. }
  229.  
  230. /**
  231.  * Does simple python-style string substitution.
  232.  * "foo%s hot%s".subs("bar", "dog") becomes "foobar hotdot".
  233.  * For more fully-featured templating, see template.js.
  234.  */
  235. String.prototype.subs = function() {
  236.   var ret = this;
  237.  
  238.   // this appears to be slow, but testing shows it compares more or less equiv.
  239.   // to the regex.exec method.
  240.   for (var i = 0; i < arguments.length; i++) {
  241.     ret = ret.replace(/\%s/, String(arguments[i]));
  242.   }
  243.  
  244.   return ret;
  245. }
  246.  
  247. /**
  248.  * Returns the last element on an array without removing it.
  249.  */
  250. Array.prototype.peek = function() {
  251.   return this[this.length - 1];
  252. }
  253.  
  254. // TODO(anyone): add splice the first time someone needs it and then implement
  255. // push, pop, shift, unshift in terms of it where possible.
  256.  
  257. // TODO(anyone): add the other neat-o functional methods like map(), etc.
  258.  
  259. /**
  260.  * Partially applies this function to a particular "this object" and zero or
  261.  * more arguments. The result is a new function with some arguments of the first
  262.  * function pre-filled and the value of |this| "pre-specified".
  263.  *
  264.  * Remaining arguments specified at call-time are appended to the pre-
  265.  * specified ones.
  266.  *
  267.  * Also see: partial().
  268.  *
  269.  * Note that bind and partial are optimized such that repeated calls to it do 
  270.  * not create more than one function object, so there is no additional cost for
  271.  * something like:
  272.  *
  273.  * var g = bind(f, obj);
  274.  * var h = partial(g, 1, 2, 3);
  275.  * var k = partial(h, a, b, c);
  276.  *
  277.  * Usage:
  278.  * var barMethBound = bind(myFunction, myObj, "arg1", "arg2");
  279.  * barMethBound("arg3", "arg4");
  280.  *
  281.  * @param thisObj {object} Specifies the object which |this| should point to
  282.  * when the function is run. If the value is null or undefined, it will default
  283.  * to the global object.
  284.  *
  285.  * @returns {function} A partially-applied form of the function bind() was
  286.  * invoked as a method of.
  287.  */
  288. function bind(fn, self, opt_args) {
  289.   var boundargs = (typeof fn.boundArgs_ != "undefined") ? fn.boundArgs_ : [];
  290.   boundargs = boundargs.concat(Array.prototype.slice.call(arguments, 2));
  291.  
  292.   if (typeof fn.boundSelf_ != "undefined") {
  293.     self = fn.boundSelf_;
  294.   }
  295.  
  296.   if (typeof fn.boundFn_ != "undefined") {
  297.     fn = fn.boundFn_;
  298.   }
  299.  
  300.   var newfn = function() {
  301.     // Combine the static args and the new args into one big array
  302.     var args = boundargs.concat(Array.prototype.slice.call(arguments));
  303.     return fn.apply(self, args);
  304.   }
  305.  
  306.   newfn.boundArgs_ = boundargs;
  307.   newfn.boundSelf_ = self;
  308.   newfn.boundFn_ = fn;
  309.  
  310.   return newfn;
  311. }
  312.  
  313. /**
  314.  * An alias to the bind() global function.
  315.  *
  316.  * Usage:
  317.  * var g = f.bind(obj, arg1, arg2);
  318.  * g(arg3, arg4);
  319.  */
  320. Function.prototype.bind = function(self, opt_args) {
  321.   return bind.apply(
  322.     null, [this, self].concat(Array.prototype.slice.call(arguments, 1)));
  323. }
  324.  
  325. /**
  326.  * Like bind(), except that a "this object" is not required. Useful when the
  327.  * target function is already bound.
  328.  * 
  329.  * Usage:
  330.  * var g = partial(f, arg1, arg2);
  331.  * g(arg3, arg4);
  332.  */
  333. function partial(fn, opt_args) {
  334.   return bind.apply(
  335.     null, [fn, null].concat(Array.prototype.slice.call(arguments, 1)));
  336. }
  337.  
  338. /**
  339.  * An alias to the partial() global function.
  340.  *
  341.  * Usage:
  342.  * var g = f.partial(arg1, arg2);
  343.  * g(arg3, arg4);
  344.  */
  345. Function.prototype.partial = function(opt_args) {
  346.   return bind.apply(
  347.     null, [this, null].concat(Array.prototype.slice.call(arguments)));
  348. }
  349.  
  350. /**
  351.  * Convenience. Binds all the methods of obj to itself. Calling this in the
  352.  * constructor before referencing any methods makes things a little more like
  353.  * Java or Python where methods are intrinsically bound to their instance.
  354.  */
  355. function bindMethods(obj) {
  356.   for (var p in obj) {
  357.     if (isFunction(obj[p])) {
  358.       obj[p] = obj[p].bind(obj);
  359.     }
  360.   }
  361. }
  362.  
  363. /**
  364.  * Inherit the prototype methods from one constructor into another.
  365.  *
  366.  * Usage:
  367.  * <pre>
  368.  * function ParentClass(a, b) { }
  369.  * ParentClass.prototype.foo = function(a) { }
  370.  *
  371.  * function ChildClass(a, b, c) {
  372.  *   ParentClass.call(this, a, b);
  373.  * }
  374.  *
  375.  * ChildClass.inherits(ParentClass);
  376.  *
  377.  * var child = new ChildClass("a", "b", "see");
  378.  * child.foo(); // works
  379.  * </pre>
  380.  *
  381.  * In addition, a superclass' implementation of a method can be invoked
  382.  * as follows:
  383.  *
  384.  * <pre>
  385.  * ChildClass.prototype.foo = function(a) {
  386.  *   ChildClass.superClass_.foo.call(this, a);
  387.  *   // other code
  388.  * };
  389.  * </pre>
  390.  */
  391. Function.prototype.inherits = function(parentCtor) {
  392.   var tempCtor = function(){};
  393.   tempCtor.prototype = parentCtor.prototype;
  394.   this.superClass_ = parentCtor.prototype;
  395.   this.prototype = new tempCtor();
  396. }
  397. /* ***** BEGIN LICENSE BLOCK *****
  398.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  399.  *
  400.  * The contents of this file are subject to the Mozilla Public License Version
  401.  * 1.1 (the "License"); you may not use this file except in compliance with
  402.  * the License. You may obtain a copy of the License at
  403.  * http://www.mozilla.org/MPL/
  404.  *
  405.  * Software distributed under the License is distributed on an "AS IS" basis,
  406.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  407.  * for the specific language governing rights and limitations under the
  408.  * License.
  409.  *
  410.  * The Original Code is Google Safe Browsing.
  411.  *
  412.  * The Initial Developer of the Original Code is Google Inc.
  413.  * Portions created by the Initial Developer are Copyright (C) 2006
  414.  * the Initial Developer. All Rights Reserved.
  415.  *
  416.  * Contributor(s):
  417.  *   Fritz Schneider <fritz@google.com> (original author)
  418.  *
  419.  * Alternatively, the contents of this file may be used under the terms of
  420.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  421.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  422.  * in which case the provisions of the GPL or the LGPL are applicable instead
  423.  * of those above. If you wish to allow use of your version of this file only
  424.  * under the terms of either the GPL or the LGPL, and not to allow others to
  425.  * use your version of this file under the terms of the MPL, indicate your
  426.  * decision by deleting the provisions above and replace them with the notice
  427.  * and other provisions required by the GPL or the LGPL. If you do not delete
  428.  * the provisions above, a recipient may use your version of this file under
  429.  * the terms of any one of the MPL, the GPL or the LGPL.
  430.  *
  431.  * ***** END LICENSE BLOCK ***** */
  432.  
  433.  
  434. // This is the code used to interact with data encoded in the
  435. // goog-black-enchash format. The format is basically a map from
  436. // hashed hostnames to encrypted sequences of regular expressions
  437. // where the encryption key is derived from the hashed
  438. // hostname. Encoding lists like this raises the bar slightly on
  439. // deriving complete table data from the db. This data format is NOT
  440. // our idea; we would've raise the bar higher :)
  441. //
  442. // Anyway, this code is a port of the original C++ implementation by
  443. // Garret. To ease verification, I mirrored that code as closely as
  444. // possible.  As a result, you'll see some C++-style variable naming
  445. // and roundabout (C++) ways of doing things. Additionally, I've
  446. // omitted the comments.
  447. //
  448. // This code should not change, except to fix bugs.
  449. //
  450. // TODO: verify that using encodeURI() in getCanonicalHost is OK
  451. // TODO: accommodate other kinds of perl-but-not-javascript qualifiers
  452.  
  453.  
  454. /**
  455.  * This thing knows how to generate lookup keys and decrypt values found in
  456.  * a table of type enchash.
  457.  */
  458. function PROT_EnchashDecrypter() {
  459.   this.debugZone = "enchashdecrypter";
  460.   this.REs_ = PROT_EnchashDecrypter.REs;
  461.   this.hasher_ = new G_CryptoHasher();
  462.   this.base64_ = new G_Base64();
  463.   this.streamCipher_ = Cc["@mozilla.org/security/streamcipher;1"]
  464.                        .createInstance(Ci.nsIStreamCipher);
  465. }
  466.  
  467. PROT_EnchashDecrypter.DATABASE_SALT = "oU3q.72p";
  468. PROT_EnchashDecrypter.SALT_LENGTH = PROT_EnchashDecrypter.DATABASE_SALT.length;
  469.  
  470. PROT_EnchashDecrypter.MAX_DOTS = 5;
  471.  
  472. PROT_EnchashDecrypter.REs = {};
  473. PROT_EnchashDecrypter.REs.FIND_DODGY_CHARS = 
  474.   new RegExp("[\x01-\x1f\x7f-\xff]+");
  475. PROT_EnchashDecrypter.REs.FIND_DODGY_CHARS_GLOBAL = 
  476.   new RegExp("[\x01-\x1f\x7f-\xff]+", "g");
  477. PROT_EnchashDecrypter.REs.FIND_END_DOTS = new RegExp("^\\.+|\\.+$");
  478. PROT_EnchashDecrypter.REs.FIND_END_DOTS_GLOBAL = 
  479.   new RegExp("^\\.+|\\.+$", "g");
  480. PROT_EnchashDecrypter.REs.FIND_MULTIPLE_DOTS = new RegExp("\\.{2,}");
  481. PROT_EnchashDecrypter.REs.FIND_MULTIPLE_DOTS_GLOBAL = 
  482.   new RegExp("\\.{2,}", "g");
  483. PROT_EnchashDecrypter.REs.FIND_TRAILING_SPACE =
  484.   new RegExp("^(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}) ");
  485. PROT_EnchashDecrypter.REs.FIND_TRAILING_DOTS = new RegExp("\\.+$");
  486. PROT_EnchashDecrypter.REs.POSSIBLE_IP = 
  487.   new RegExp("^((?:0x[0-9a-f]+|[0-9\\.])+)$", "i");
  488. PROT_EnchashDecrypter.REs.FIND_BAD_OCTAL = new RegExp("(^|\\.)0\\d*[89]");
  489. PROT_EnchashDecrypter.REs.IS_OCTAL = new RegExp("^0[0-7]*$");
  490. PROT_EnchashDecrypter.REs.IS_DECIMAL = new RegExp("^[0-9]+$");
  491. PROT_EnchashDecrypter.REs.IS_HEX = new RegExp("^0[xX]([0-9a-fA-F]+)$");
  492.  
  493. // Regexps are given in perl regexp format. Unfortunately, JavaScript's
  494. // library isn't completely compatible. For example, you can't specify
  495. // case-insensitive matching by using (?i) in the expression text :(
  496. // So we manually set this bit with the help of this regular expression.
  497. PROT_EnchashDecrypter.REs.CASE_INSENSITIVE = /\(\?i\)/g;
  498.  
  499. /**
  500.  * Helper function 
  501.  *
  502.  * @param str String to get chars from
  503.  * 
  504.  * @param n Number of characters to get
  505.  *
  506.  * @returns String made up of the last n characters of str
  507.  */ 
  508. PROT_EnchashDecrypter.prototype.lastNChars_ = function(str, n) {
  509.   n = -n;
  510.   return str.substr(n);
  511. }
  512.  
  513. /**
  514.  * We have to have our own hex-decoder because decodeURIComponent
  515.  * expects UTF-8 (so it will barf on invalid UTF-8 sequences).
  516.  *
  517.  * @param str String to decode
  518.  * 
  519.  * @returns The decoded string
  520.  */
  521. PROT_EnchashDecrypter.prototype.hexDecode_ = function(str) {
  522.   var output = [];
  523.  
  524.   var i = 0;
  525.   while (i < str.length) {
  526.     var c = str.charAt(i);
  527.   
  528.     if (c == "%" && i + 2 < str.length) {
  529.  
  530.       var asciiVal = Number("0x" + str.charAt(i + 1) + str.charAt(i + 2));
  531.       
  532.       if (!isNaN(asciiVal)) {
  533.         i += 2;
  534.         c = String.fromCharCode(asciiVal);
  535.       }
  536.     }
  537.     
  538.     output[output.length] = c;
  539.     ++i;
  540.   }
  541.   
  542.   return output.join("");
  543. }
  544.  
  545. /**
  546.  * Translate a plaintext enchash value into regular expressions
  547.  *
  548.  * @param data String containing a decrypted enchash db entry
  549.  *
  550.  * @returns An array of RegExps
  551.  */
  552. PROT_EnchashDecrypter.prototype.parseRegExps = function(data) {
  553.   var res = data.split("\t");
  554.   
  555.   G_Debug(this, "Got " + res.length + " regular rexpressions");
  556.   
  557.   for (var i = 0; i < res.length; i++) {
  558.     // Could have leading (?i); if so, set the flag and strip it
  559.     var flags = (this.REs_.CASE_INSENSITIVE.test(res[i])) ? "i" : "";
  560.     res[i] = res[i].replace(this.REs_.CASE_INSENSITIVE, "");
  561.     res[i] = new RegExp(res[i], flags);
  562.   }
  563.  
  564.   return res;
  565. }
  566.  
  567. /**
  568.  * Get the canonical version of the given URL for lookup in a table of 
  569.  * type -url.
  570.  *
  571.  * @param url String to canonicalize
  572.  *
  573.  * @returns String containing the canonicalized url (maximally url-decoded
  574.  *          with hostname normalized, then specially url-encoded)
  575.  */
  576. PROT_EnchashDecrypter.prototype.getCanonicalUrl = function(url) {
  577.   var urlUtils = Cc["@mozilla.org/url-classifier/utils;1"]
  578.                  .getService(Ci.nsIUrlClassifierUtils);
  579.   var escapedUrl = urlUtils.canonicalizeURL(url);
  580.   // Normalize the host
  581.   var host = this.getCanonicalHost(escapedUrl);
  582.   if (!host) {
  583.     // Probably an invalid url, return what we have so far.
  584.     return escapedUrl;
  585.   }
  586.  
  587.   // Combine our normalized host with our escaped url.
  588.   var ioService = Cc["@mozilla.org/network/io-service;1"]
  589.                   .getService(Ci.nsIIOService);
  590.   var urlObj = ioService.newURI(escapedUrl, null, null);
  591.   urlObj.host = host;
  592.   return urlObj.asciiSpec;
  593. }
  594.  
  595. /**
  596.  * @param opt_maxDots Number maximum number of dots to include.
  597.  */
  598. PROT_EnchashDecrypter.prototype.getCanonicalHost = function(str, opt_maxDots) {
  599.   var ioService = Cc["@mozilla.org/network/io-service;1"]
  600.                   .getService(Ci.nsIIOService);
  601.   try {
  602.     var urlObj = ioService.newURI(str, null, null);
  603.     var asciiHost = urlObj.asciiHost;
  604.   } catch (e) {
  605.     G_Debug(this, "Unable to get hostname: " + str);
  606.     return "";
  607.   }
  608.  
  609.   var unescaped = this.hexDecode_(asciiHost);
  610.  
  611.   unescaped = unescaped.replace(this.REs_.FIND_DODGY_CHARS_GLOBAL, "")
  612.               .replace(this.REs_.FIND_END_DOTS_GLOBAL, "")
  613.               .replace(this.REs_.FIND_MULTIPLE_DOTS_GLOBAL, ".");
  614.  
  615.   var temp = this.parseIPAddress_(unescaped);
  616.   if (temp)
  617.     unescaped = temp;
  618.  
  619.   // TODO: what, exactly is it supposed to escape? This doesn't esecape 
  620.   // ":", "/", ";", and "?"
  621.   var escaped = encodeURI(unescaped);
  622.  
  623.   if (opt_maxDots) {
  624.     // Limit the number of dots
  625.     var k;
  626.     var index = escaped.length;
  627.     for (k = 0; k < opt_maxDots + 1; k++) {
  628.       temp = escaped.lastIndexOf(".", index - 1);
  629.       if (temp == -1) {
  630.         break;
  631.       } else {
  632.         index = temp;
  633.       }
  634.     }
  635.     
  636.     if (k == opt_maxDots + 1 && index != -1) {
  637.       escaped = escaped.substring(index + 1);
  638.     }
  639.   }
  640.  
  641.   escaped = escaped.toLowerCase();
  642.   return escaped;
  643. }
  644.  
  645. PROT_EnchashDecrypter.prototype.parseIPAddress_ = function(host) {
  646.  
  647.   host = host.replace(this.REs_.FIND_TRAILING_DOTS_GLOBAL, "");
  648.  
  649.   if (host.length <= 15) {
  650.     // The Windows resolver allows a 4-part dotted decimal IP address to
  651.     // have a space followed by any old rubbish, so long as the total length
  652.     // of the string doesn't get above 15 characters. So, "10.192.95.89 xy"
  653.     // is resolved to 10.192.95.89.
  654.     // If the string length is greater than 15 characters, e.g.
  655.     // "10.192.95.89 xy.wildcard.example.com", it will be resolved through
  656.     // DNS.
  657.     var match = this.REs_.FIND_TRAILING_SPACE.exec(host);
  658.     if (match) {
  659.       host = match[1];
  660.     }
  661.   }
  662.  
  663.   if (!this.REs_.POSSIBLE_IP.test(host))
  664.     return "";
  665.  
  666.   var parts = host.split(".");
  667.   if (parts.length > 4)
  668.     return "";
  669.  
  670.   var allowOctal = !this.REs_.FIND_BAD_OCTAL.test(host);
  671.  
  672.   for (var k = 0; k < parts.length; k++) {
  673.     var canon;
  674.     if (k == parts.length - 1) {
  675.       canon = this.canonicalNum_(parts[k], 5 - parts.length, allowOctal);
  676.     } else {
  677.       canon = this.canonicalNum_(parts[k], 1, allowOctal);
  678.     }
  679.     if (canon != "") 
  680.       parts[k] = canon;
  681.     else
  682.       return "";
  683.   }
  684.  
  685.   return parts.join(".");
  686. }
  687.  
  688. PROT_EnchashDecrypter.prototype.canonicalNum_ = function(num, bytes, octal) {
  689.   if (bytes < 0) 
  690.     return "";
  691.   var temp_num;
  692.  
  693.   if (octal && this.REs_.IS_OCTAL.test(num)) {
  694.  
  695.     num = this.lastNChars_(num, 11);
  696.  
  697.     temp_num = parseInt(num, 8);
  698.     if (isNaN(temp_num))
  699.       temp_num = -1;
  700.  
  701.   } else if (this.REs_.IS_DECIMAL.test(num)) {
  702.  
  703.     num = this.lastNChars_(num, 32);
  704.  
  705.     temp_num = parseInt(num, 10);
  706.     if (isNaN(temp_num))
  707.       temp_num = -1;
  708.  
  709.   } else if (this.REs_.IS_HEX.test(num)) {
  710.     var matches = this.REs_.IS_HEX.exec(num);
  711.     if (matches) {
  712.       num = matches[1];
  713.     }
  714.  
  715.     temp_num = parseInt(num, 16);
  716.     if (isNaN(temp_num))
  717.       temp_num = -1;
  718.  
  719.   } else {
  720.     return "";
  721.   }
  722.  
  723.   if (temp_num == -1) 
  724.     return "";
  725.  
  726.   // Since we mod the number, we're removing the least significant bits.  We
  727.   // Want to push them into the front of the array to preserve the order.
  728.   var parts = [];
  729.   while (bytes--) {
  730.     parts.unshift("" + (temp_num % 256));
  731.     temp_num -= temp_num % 256;
  732.     temp_num /= 256;
  733.   }
  734.  
  735.   return parts.join(".");
  736. }
  737.  
  738. PROT_EnchashDecrypter.prototype.getLookupKey = function(host) {
  739.   var dataKey = PROT_EnchashDecrypter.DATABASE_SALT + host;
  740.   dataKey = this.base64_.arrayifyString(dataKey);
  741.  
  742.   this.hasher_.init(G_CryptoHasher.algorithms.MD5);
  743.   var lookupDigest = this.hasher_.updateFromArray(dataKey);
  744.   var lookupKey = this.hasher_.digestHex();
  745.  
  746.   return lookupKey.toUpperCase();
  747. }
  748.  
  749. PROT_EnchashDecrypter.prototype.decryptData = function(data, host) {
  750.   // XXX: base 64 decoding should be done in C++
  751.   var asciiArray = this.base64_.decodeString(data);
  752.   var ascii = this.base64_.stringifyArray(asciiArray);
  753.  
  754.   var random_salt = ascii.slice(0, PROT_EnchashDecrypter.SALT_LENGTH);
  755.   var encrypted_data = ascii.slice(PROT_EnchashDecrypter.SALT_LENGTH);
  756.   var temp_decryption_key = PROT_EnchashDecrypter.DATABASE_SALT
  757.       + random_salt + host;
  758.   this.hasher_.init(G_CryptoHasher.algorithms.MD5);
  759.   this.hasher_.updateFromString(temp_decryption_key);
  760.  
  761.   var keyFactory = Cc["@mozilla.org/security/keyobjectfactory;1"]
  762.                    .getService(Ci.nsIKeyObjectFactory);
  763.   var key = keyFactory.keyFromString(Ci.nsIKeyObject.RC4,
  764.                                      this.hasher_.digestRaw());
  765.  
  766.   this.streamCipher_.init(key);
  767.   this.streamCipher_.updateFromString(encrypted_data);
  768.  
  769.   return this.streamCipher_.finish(false /* no base64 */);
  770. }
  771.  
  772. /* ***** BEGIN LICENSE BLOCK *****
  773.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  774.  *
  775.  * The contents of this file are subject to the Mozilla Public License Version
  776.  * 1.1 (the "License"); you may not use this file except in compliance with
  777.  * the License. You may obtain a copy of the License at
  778.  * http://www.mozilla.org/MPL/
  779.  *
  780.  * Software distributed under the License is distributed on an "AS IS" basis,
  781.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  782.  * for the specific language governing rights and limitations under the
  783.  * License.
  784.  *
  785.  * The Original Code is Google Safe Browsing.
  786.  *
  787.  * The Initial Developer of the Original Code is Google Inc.
  788.  * Portions created by the Initial Developer are Copyright (C) 2006
  789.  * the Initial Developer. All Rights Reserved.
  790.  *
  791.  * Contributor(s):
  792.  *   Tony Chang <tony@google.com> (original author)
  793.  *
  794.  * Alternatively, the contents of this file may be used under the terms of
  795.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  796.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  797.  * in which case the provisions of the GPL or the LGPL are applicable instead
  798.  * of those above. If you wish to allow use of your version of this file only
  799.  * under the terms of either the GPL or the LGPL, and not to allow others to
  800.  * use your version of this file under the terms of the MPL, indicate your
  801.  * decision by deleting the provisions above and replace them with the notice
  802.  * and other provisions required by the GPL or the LGPL. If you do not delete
  803.  * the provisions above, a recipient may use your version of this file under
  804.  * the terms of any one of the MPL, the GPL or the LGPL.
  805.  *
  806.  * ***** END LICENSE BLOCK ***** */
  807.  
  808. /**
  809.  * This class helps us batch a series of async calls to the db.
  810.  * If any of the tokens is in the database, we fire callback with
  811.  * true as a param.  If all the tokens are not in the  database,
  812.  * we fire callback with false as a param.
  813.  * This is an "Abstract" base class.  Subclasses need to supply
  814.  * the condition_ method.
  815.  *
  816.  * @param tokens Array of strings to lookup in the db
  817.  * @param tableName String name of the table
  818.  * @param callback Function callback function that takes true if the condition
  819.  *        passes.
  820.  */
  821. function MultiQuerier(tokens, tableName, callback) {
  822.   this.tokens_ = tokens;
  823.   this.tableName_ = tableName;
  824.   this.callback_ = callback;
  825.   this.dbservice_ = Cc["@mozilla.org/url-classifier/dbservice;1"]
  826.                     .getService(Ci.nsIUrlClassifierDBService);
  827.   // We put the current token in this variable.
  828.   this.key_ = null;
  829. }
  830.  
  831. /**
  832.  * Run the remaining tokens against the db.
  833.  */
  834. MultiQuerier.prototype.run = function() {
  835.   if (this.tokens_.length == 0) {
  836.     this.callback_.handleEvent(false);
  837.     this.dbservice_ = null;
  838.     this.callback_ = null;
  839.     return;
  840.   }
  841.   
  842.   this.key_ = this.tokens_.pop();
  843.   G_Debug(this, "Looking up " + this.key_ + " in " + this.tableName_);
  844.   this.dbservice_.exists(this.tableName_, this.key_,
  845.                          BindToObject(this.result_, this));
  846. }
  847.  
  848. /**
  849.  * Callback from the db.  If the returned value passes the this.condition_
  850.  * test, go ahead and call the main callback.
  851.  */
  852. MultiQuerier.prototype.result_ = function(value) {
  853.   if (this.condition_(value)) {
  854.     this.callback_.handleEvent(true)
  855.     this.dbservice_ = null;
  856.     this.callback_ = null;
  857.   } else {
  858.     this.run();
  859.   }
  860. }
  861.  
  862. // Subclasses must override this.
  863. MultiQuerier.prototype.condition_ = function(value) {
  864.   throw "MultiQuerier is an abstract base class";
  865. }
  866.  
  867.  
  868. /**
  869.  * Concrete MultiQuerier that stops if the key exists in the db.
  870.  */
  871. function ExistsMultiQuerier(tokens, tableName, callback) {
  872.   MultiQuerier.call(this, tokens, tableName, callback);
  873.   this.debugZone = "existsMultiQuerier";
  874. }
  875. ExistsMultiQuerier.inherits(MultiQuerier);
  876.  
  877. ExistsMultiQuerier.prototype.condition_ = function(value) {
  878.   return value.length > 0;
  879. }
  880.  
  881.  
  882. /**
  883.  * Concrete MultiQuerier that looks up a key, decrypts it, then
  884.  * checks the the resulting regular expressions for a match.
  885.  * @param tokens Array of hosts
  886.  */
  887. function EnchashMultiQuerier(tokens, tableName, callback, url) {
  888.   MultiQuerier.call(this, tokens, tableName, callback);
  889.   this.url_ = url;
  890.   this.enchashDecrypter_ = new PROT_EnchashDecrypter();
  891.   this.debugZone = "enchashMultiQuerier";
  892. }
  893. EnchashMultiQuerier.inherits(MultiQuerier);
  894.  
  895. EnchashMultiQuerier.prototype.run = function() {
  896.   if (this.tokens_.length == 0) {
  897.     this.callback_.handleEvent(false);
  898.     this.dbservice_ = null;
  899.     this.callback_ = null;
  900.     return;
  901.   }
  902.   var host = this.tokens_.pop();
  903.   this.key_ = host;
  904.   var lookupKey = this.enchashDecrypter_.getLookupKey(host);
  905.   this.dbservice_.exists(this.tableName_, lookupKey,
  906.                          BindToObject(this.result_, this));
  907. }
  908.  
  909. EnchashMultiQuerier.prototype.condition_ = function(encryptedValue) {
  910.   if (encryptedValue.length > 0) {
  911.     // We have encrypted regular expressions for this host. Let's 
  912.     // decrypt them and see if we have a match.
  913.     var decrypted = this.enchashDecrypter_.decryptData(encryptedValue,
  914.                                                        this.key_);
  915.     var res = this.enchashDecrypter_.parseRegExps(decrypted);
  916.     for (var j = 0; j < res.length; j++) {
  917.       if (res[j].test(this.url_)) {
  918.         return true;
  919.       }
  920.     }
  921.   }
  922.   return false;
  923. }
  924. /* ***** BEGIN LICENSE BLOCK *****
  925.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  926.  *
  927.  * The contents of this file are subject to the Mozilla Public License Version
  928.  * 1.1 (the "License"); you may not use this file except in compliance with
  929.  * the License. You may obtain a copy of the License at
  930.  * http://www.mozilla.org/MPL/
  931.  *
  932.  * Software distributed under the License is distributed on an "AS IS" basis,
  933.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  934.  * for the specific language governing rights and limitations under the
  935.  * License.
  936.  *
  937.  * The Original Code is Url Classifier code
  938.  *
  939.  * The Initial Developer of the Original Code is
  940.  * Google Inc.
  941.  * Portions created by the Initial Developer are Copyright (C) 2006
  942.  * the Initial Developer. All Rights Reserved.
  943.  *
  944.  * Contributor(s):
  945.  *   Tony Chang <tony@ponderer.org>
  946.  *
  947.  * Alternatively, the contents of this file may be used under the terms of
  948.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  949.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  950.  * in which case the provisions of the GPL or the LGPL are applicable instead
  951.  * of those above. If you wish to allow use of your version of this file only
  952.  * under the terms of either the GPL or the LGPL, and not to allow others to
  953.  * use your version of this file under the terms of the MPL, indicate your
  954.  * decision by deleting the provisions above and replace them with the notice
  955.  * and other provisions required by the GPL or the LGPL. If you do not delete
  956.  * the provisions above, a recipient may use your version of this file under
  957.  * the terms of any one of the MPL, the GPL or the LGPL.
  958.  *
  959.  * ***** END LICENSE BLOCK ***** */
  960.  
  961. // XXX: This should all be moved into the dbservice class so it happens
  962. // in the background thread.
  963.  
  964. /**
  965.  * Abstract base class for a lookup table.
  966.  * @construction
  967.  */
  968. function UrlClassifierTable() {
  969.   this.debugZone = "urlclassifier-table";
  970.   this.name = '';
  971.   this.needsUpdate = false;
  972.   this.enchashDecrypter_ = new PROT_EnchashDecrypter();
  973. }
  974.  
  975. UrlClassifierTable.prototype.QueryInterface = function(iid) {
  976.   if (iid.equals(Components.interfaces.nsISupports) ||
  977.       iid.equals(Components.interfaces.nsIUrlClassifierTable))
  978.     return this;                                              
  979.   Components.returnCode = Components.results.NS_ERROR_NO_INTERFACE;
  980.   return null;
  981. }
  982.  
  983. /**
  984.  * Subclasses need to implment this method.
  985.  */
  986. UrlClassifierTable.prototype.exists = function(url, callback) {
  987.   throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  988. }
  989.  
  990. /////////////////////////////////////////////////////////////////////
  991. // Url table implementation
  992. function UrlClassifierTableUrl() {
  993.   UrlClassifierTable.call(this);
  994. }
  995. UrlClassifierTableUrl.inherits(UrlClassifierTable);
  996.  
  997. /**
  998.  * Look up a URL in a URL table
  999.  */
  1000. UrlClassifierTableUrl.prototype.exists = function(url, callback) {
  1001.   // nsIUrlClassifierUtils.canonicalizeURL is the old way of canonicalizing a
  1002.   // URL.  Unfortunately, it doesn't normalize numeric domains so alternate IP
  1003.   // formats (hex, octal, etc) won't trigger a match.
  1004.   // this.enchashDecrypter_.getCanonicalUrl does the right thing and
  1005.   // normalizes a URL to 4 decimal numbers, but the update server may still be
  1006.   // giving us encoded IP addresses.  So to be safe, we check both cases.
  1007.   var urlUtils = Cc["@mozilla.org/url-classifier/utils;1"]
  1008.                  .getService(Ci.nsIUrlClassifierUtils);
  1009.   var oldCanonicalized = urlUtils.canonicalizeURL(url);
  1010.   var canonicalized = this.enchashDecrypter_.getCanonicalUrl(url);
  1011.   G_Debug(this, "Looking up: " + url + " (" + oldCanonicalized + " and " +
  1012.                 canonicalized + ")");
  1013.   (new ExistsMultiQuerier([oldCanonicalized, canonicalized],
  1014.                           this.name,
  1015.                           callback)).run();
  1016. }
  1017.  
  1018. /////////////////////////////////////////////////////////////////////
  1019. // Domain table implementation
  1020.  
  1021. function UrlClassifierTableDomain() {
  1022.   UrlClassifierTable.call(this);
  1023.   this.debugZone = "urlclassifier-table-domain";
  1024.   this.ioService_ = Cc["@mozilla.org/network/io-service;1"]
  1025.                     .getService(Ci.nsIIOService);
  1026. }
  1027. UrlClassifierTableDomain.inherits(UrlClassifierTable);
  1028.  
  1029. /**
  1030.  * Look up a URL in a domain table
  1031.  * We also try to lookup domain + first path component (e.g.,
  1032.  * www.mozilla.org/products).
  1033.  *
  1034.  * @returns Boolean true if the url domain is in the table
  1035.  */
  1036. UrlClassifierTableDomain.prototype.exists = function(url, callback) {
  1037.   var canonicalized = this.enchashDecrypter_.getCanonicalUrl(url);
  1038.   var urlObj = this.ioService_.newURI(canonicalized, null, null);
  1039.   var host = '';
  1040.   try {
  1041.     host = urlObj.host;
  1042.   } catch (e) { }
  1043.   var hostComponents = host.split(".");
  1044.  
  1045.   // Try to get the path of the URL.  Pseudo urls (like wyciwyg:) throw
  1046.   // errors when trying to convert to an nsIURL so we wrap in a try/catch
  1047.   // block.
  1048.   var path = ""
  1049.   try {
  1050.     urlObj.QueryInterface(Ci.nsIURL);
  1051.     path = urlObj.filePath;
  1052.   } catch (e) { }
  1053.  
  1054.   var pathComponents = path.split("/");
  1055.  
  1056.   // We don't have a good way map from hosts to domains, so we instead try
  1057.   // each possibility. Could probably optimize to start at the second dot?
  1058.   var possible = [];
  1059.   for (var i = 0; i < hostComponents.length - 1; i++) {
  1060.     host = hostComponents.slice(i).join(".");
  1061.     possible.push(host);
  1062.  
  1063.     // The path starts with a "/", so we are interested in the second path
  1064.     // component if it is available
  1065.     if (pathComponents.length >= 2 && pathComponents[1].length > 0) {
  1066.       host = host + "/" + pathComponents[1];
  1067.       possible.push(host);
  1068.     }
  1069.   }
  1070.  
  1071.   // Run the possible domains against the db.
  1072.   (new ExistsMultiQuerier(possible, this.name, callback)).run();
  1073. }
  1074.  
  1075. /////////////////////////////////////////////////////////////////////
  1076. // Enchash table implementation
  1077.  
  1078. function UrlClassifierTableEnchash() {
  1079.   UrlClassifierTable.call(this);
  1080.   this.debugZone = "urlclassifier-table-enchash";
  1081. }
  1082. UrlClassifierTableEnchash.inherits(UrlClassifierTable);
  1083.  
  1084. /**
  1085.  * Look up a URL in an enchashDB.  We try all sub domains (up to MAX_DOTS).
  1086.  */
  1087. UrlClassifierTableEnchash.prototype.exists = function(url, callback) {
  1088.   url = this.enchashDecrypter_.getCanonicalUrl(url);
  1089.   var host = this.enchashDecrypter_.getCanonicalHost(url,
  1090.                                                PROT_EnchashDecrypter.MAX_DOTS);
  1091.  
  1092.   var possible = [];
  1093.   for (var i = 0; i < PROT_EnchashDecrypter.MAX_DOTS + 1; i++) {
  1094.     possible.push(host);
  1095.  
  1096.     var index = host.indexOf(".");
  1097.     if (index == -1)
  1098.       break;
  1099.     host = host.substring(index + 1);
  1100.   }
  1101.   // Run the possible domains against the db.
  1102.   (new EnchashMultiQuerier(possible, this.name, callback, url)).run();
  1103. }
  1104. //@line 46 "/cygdrive/K/tinderbuild/src/flock/mozilla/toolkit/components/url-classifier/src/nsUrlClassifierTable.js"
  1105.  
  1106. var modScope = this;
  1107. function Init() {
  1108.   // Pull the library in.
  1109.   var jslib = Cc["@mozilla.org/url-classifier/jslib;1"]
  1110.               .getService().wrappedJSObject;
  1111.   modScope.G_Preferences = jslib.G_Preferences;
  1112.   modScope.G_PreferenceObserver = jslib.G_PreferenceObserver;
  1113.   modScope.G_Debug = jslib.G_Debug;
  1114.   modScope.G_CryptoHasher = jslib.G_CryptoHasher;
  1115.   modScope.G_Base64 = jslib.G_Base64;
  1116.   modScope.BindToObject = jslib.BindToObject;
  1117.  
  1118.   // We only need to call Init once.
  1119.   modScope.Init = function() {};
  1120. }
  1121.  
  1122.  
  1123. function UrlClassifierTableMod() {
  1124.   this.components = {};
  1125.   this.addComponent({
  1126.       cid: "{43399ee0-da0b-46a8-9541-08721265981c}",
  1127.       name: "UrlClassifier Table Url Module",
  1128.       progid: "@mozilla.org/url-classifier/table;1?type=url",
  1129.       factory: new UrlClassifierTableFactory(UrlClassifierTableUrl)
  1130.     });
  1131.   this.addComponent({
  1132.       cid: "{3b5004c6-3fcd-4b12-b311-a4dfbeaf27aa}",
  1133.       name: "UrlClassifier Table Domain Module",
  1134.       progid: "@mozilla.org/url-classifier/table;1?type=domain",
  1135.       factory: new UrlClassifierTableFactory(UrlClassifierTableDomain)
  1136.     });
  1137.   this.addComponent({
  1138.       cid: "{04f15d1d-2db8-4b8e-91d7-82f30308b434}",
  1139.       name: "UrlClassifier Table Enchash Module",
  1140.       progid: "@mozilla.org/url-classifier/table;1?type=enchash",
  1141.       factory: new UrlClassifierTableFactory(UrlClassifierTableEnchash)
  1142.     });
  1143. }
  1144.  
  1145. UrlClassifierTableMod.prototype.addComponent = function(comp) {
  1146.   this.components[comp.cid] = comp;
  1147. };
  1148.  
  1149. UrlClassifierTableMod.prototype.registerSelf = function(compMgr, fileSpec, loc, type) {
  1150.   compMgr = compMgr.QueryInterface(Ci.nsIComponentRegistrar);
  1151.   // Register all the components
  1152.   for (var cid in this.components) {
  1153.     var comp = this.components[cid];
  1154.     compMgr.registerFactoryLocation(Components.ID(comp.cid),
  1155.                                     comp.name,
  1156.                                     comp.progid,
  1157.                                     fileSpec,
  1158.                                     loc,
  1159.                                     type);
  1160.   }
  1161. };
  1162.  
  1163. UrlClassifierTableMod.prototype.getClassObject = function(compMgr, cid, iid) {
  1164.   var comp = this.components[cid.toString()];
  1165.  
  1166.   if (!comp)
  1167.     throw Components.results.NS_ERROR_NO_INTERFACE;
  1168.   if (!iid.equals(Ci.nsIFactory))
  1169.     throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  1170.  
  1171.   return comp.factory;
  1172. };
  1173.  
  1174. UrlClassifierTableMod.prototype.canUnload = function(compMgr) {
  1175.   return true;
  1176. };
  1177.  
  1178. /**
  1179.  * Create a factory.
  1180.  * @param ctor Function constructor for the object we're creating.
  1181.  */
  1182. function UrlClassifierTableFactory(ctor) {
  1183.   this.ctor = ctor;
  1184. }
  1185.  
  1186. UrlClassifierTableFactory.prototype.createInstance = function(outer, iid) {
  1187.   if (outer != null)
  1188.     throw Components.results.NS_ERROR_NO_AGGREGATION;
  1189.   Init();
  1190.   return (new this.ctor()).QueryInterface(iid);
  1191. };
  1192.  
  1193. var modInst = new UrlClassifierTableMod();
  1194.  
  1195. function NSGetModule(compMgr, fileSpec) {
  1196.   return modInst;
  1197. }
  1198.